home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 3 / BBS in a box - Trilogy III.iso / Files / Prog / B-C / C++Source Code Fmtr Folder / Src / HandleManager.cp < prev    next >
Encoding:
Text File  |  1992-04-27  |  6.5 KB  |  321 lines  |  [TEXT/MPS ]
  1. #ifndef __HANDLEMANAGER__
  2. #include "HandleManager.h"
  3. #endif
  4.  
  5. #ifndef __MEMORY__
  6. #include <memory.h>
  7. #endif
  8.  
  9. #ifndef __OSUTILS__
  10. #include <osutils.h>
  11. #endif
  12.  
  13.  
  14. // Default is only application heap is used
  15. Boolean HandleManager::fMaySpecifyTempMemory = false;
  16.  
  17.  
  18.  
  19.  
  20. /*µ class SystemHandleManager
  21. **    This class implements the HandleManager primitives for items allocated
  22. ** from the system heap.  Most of the methods are identical with the those
  23. ** in HandleManager.
  24. */
  25. class SystemHandleManager : public HandleManager {
  26. public:
  27.     virtual void MoveHHi(void **aHandle, OSErr *anErr);
  28.     virtual void **NewHandle(size_t aSize, OSErr *anErr);
  29.     virtual void Duplicate(void **aSrcHandle, void ***aDstHandle, OSErr *anErr);
  30.     virtual size_t FreeMem();
  31.     virtual size_t MaxMem(size_t *grow);
  32. };
  33.  
  34.  
  35. //µ   SystemHandleManager::MoveHHi
  36. #pragma segment HandleManager
  37. void SystemHandleManager::MoveHHi(void **, OSErr *anErr)
  38. {
  39.     // Do nothing
  40.     *anErr = noErr;
  41. }
  42.  
  43.  
  44. //µ   SystemHandleManager::NewHandle
  45. #pragma segment HandleManager
  46. void **SystemHandleManager::NewHandle(size_t aSize, OSErr *anErr)
  47. {
  48.     void **aHandle = ::NewHandleSysClear((Size)aSize);
  49.  
  50.     *anErr = MemError();
  51.     return (aHandle);
  52. }
  53.  
  54.  
  55. //µ   SystemHandleManager::Duplicate
  56. #pragma segment HandleManager
  57. void SystemHandleManager::Duplicate(void **aSrcHandle, void ***aDstHandle, OSErr *anErr)
  58. {
  59.     size_t aSize = GetHandleSize(aSrcHandle, anErr);
  60.  
  61.     if (anErr == noErr) {
  62.         *aDstHandle = NewHandle(aSize, anErr);
  63.         if (*anErr == noErr)
  64.             BlockMove(*aSrcHandle, **aDstHandle, aSize);
  65.     }
  66. }
  67.  
  68.  
  69. //µ   SystemHandleManager::FreeMem
  70. #pragma segment HandleManager
  71. size_t SystemHandleManager::FreeMem()
  72. {
  73.     THz aZone = GetZone();
  74.  
  75.     SetZone(SystemZone());
  76.     size_t avail = (size_t)::FreeMem();
  77.     SetZone(aZone);
  78.  
  79.     return (avail);
  80. }
  81.  
  82.  
  83. //µ   SystemHandleManager::MaxMem
  84. #pragma segment HandleManager
  85. size_t SystemHandleManager::MaxMem(size_t *grow)
  86. {
  87.     THz aZone = GetZone();
  88.  
  89.     SetZone(SystemZone());
  90.     size_t aSize = (size_t)::MaxMem((Size *)grow);
  91.     SetZone(aZone);
  92.  
  93.     return (aSize);
  94. }
  95.  
  96.  
  97.  
  98. /*µ class TempHandleManager
  99. **    This class implements the HandleManager primitives for items allocated
  100. ** from the MultiFinder heap.  It assumes the existence of System 7.0.  Note
  101. ** that the class is derived from SystemHandleManager as this class's needs are similar
  102. ** to those of SystemHandleManager.  
  103. */
  104. class TempHandleManager : public SystemHandleManager {
  105. public:
  106.     virtual void Lock(void **aHandle, OSErr *anErr);
  107.     virtual void Unlock(void **aHandle, OSErr *anErr);
  108.     virtual void **NewHandle(size_t aSize, OSErr *anErr);
  109.     virtual void DisposHandle(void **aHandle, OSErr *anErr);
  110.     virtual size_t FreeMem();
  111.     virtual size_t MaxMem(size_t *grow);
  112. };
  113.  
  114.  
  115. //µ   TempHandleManager::NewHandle
  116. #pragma segment HandleManager
  117. void **TempHandleManager::NewHandle(size_t aSize, OSErr *anErr)
  118. {
  119.     return (::TempNewHandle((Size)aSize, anErr));
  120. }
  121.  
  122.  
  123. //µ   TempHandleManager::Lock
  124. #pragma segment HandleManager
  125. void TempHandleManager::Lock(void **aHandle, OSErr *anErr)
  126. {
  127.     ::TempHLock((Handle)aHandle, anErr);
  128. }
  129.  
  130.  
  131. //µ   TempHandleManager::Unlock
  132. #pragma segment HandleManager
  133. void TempHandleManager::Unlock(void **aHandle, OSErr *anErr)
  134. {
  135.     ::TempHUnlock((Handle)aHandle, anErr);
  136. }
  137.  
  138.  
  139. //µ   TempHandleManager::DisposHandle
  140. #pragma segment HandleManager
  141. void TempHandleManager::DisposHandle(void **aHandle, OSErr *anErr)
  142. {
  143.     ::TempDisposeHandle((Handle)aHandle, anErr);
  144. }
  145.  
  146.  
  147. //µ   TempHandleManager::FreeMem
  148. #pragma segment HandleManager
  149. size_t TempHandleManager::FreeMem()
  150. {
  151.     return ((size_t)::TempFreeMem());
  152. }
  153.  
  154.  
  155. //µ   TempHandleManager::MaxMem
  156. #pragma segment HandleManager
  157. size_t TempHandleManager::MaxMem(size_t *grow)
  158. {
  159.     return ((size_t)::TempMaxMem((Size *)grow));
  160. }
  161.  
  162.  
  163.  
  164. //µ –- HandleManager implementation -–
  165.  
  166. //µ   HandleManager::SetHandleSize
  167. #pragma segment HandleManager
  168. void HandleManager::SetHandleSize(void **aHandle, size_t newSize, OSErr *anErr)
  169. {
  170.     ::SetHandleSize((Handle)aHandle, (Size)newSize);
  171.     *anErr = MemError();
  172. }
  173.  
  174.  
  175. //µ   HandleManager::GetHandleSize
  176. #pragma segment HandleManager
  177. size_t HandleManager::GetHandleSize(void **aHandle, OSErr *anErr)
  178. {
  179.     Size aSize = ::GetHandleSize((Handle)aHandle);
  180.  
  181.     *anErr = MemError();
  182.     return ((size_t)aSize);
  183. }
  184.  
  185.  
  186. //µ   HandleManager::HLock
  187. #pragma segment HandleManager
  188. void HandleManager::HLock(void **aHandle, OSErr *anErr)
  189. {
  190.     ::HLock((Handle)aHandle);
  191.     *anErr = MemError();
  192. }
  193.  
  194.  
  195. //µ   HandleManager::HUnlock
  196. #pragma segment HandleManager
  197. void HandleManager::HUnlock(void **aHandle, OSErr *anErr)
  198. {
  199.     ::HUnlock((Handle)aHandle);
  200.     *anErr = MemError();
  201. }
  202.  
  203.  
  204. //µ   HandleManager::MoveHHi
  205. #pragma segment HandleManager
  206. void HandleManager::MoveHHi(void **aHandle, OSErr *anErr)
  207. {
  208.     ::MoveHHi((Handle)aHandle);
  209.     *anErr = MemError();
  210. }
  211.  
  212.  
  213. //µ   HandleManager::NewHandle
  214. #pragma segment HandleManager
  215. void **HandleManager::NewHandle(size_t aSize, OSErr *anErr)
  216. {
  217.     THz aZone = GetZone();
  218.  
  219.     SetZone(ApplicZone());
  220.     void **aHandle = ::NewHandleClear((Size)aSize);
  221.     SetZone(aZone);
  222.  
  223.     *anErr = MemError();
  224.     return (aHandle);
  225. }
  226.  
  227.  
  228. //µ   HandleManager::Duplicate
  229. #pragma segment HandleManager
  230. void HandleManager::Duplicate(void **aSrcHandle, void ***aDstHandle, OSErr *anErr)
  231. {
  232.     THz aZone = GetZone();
  233.  
  234.     SetZone(ApplicZone());
  235.     *aDstHandle = aSrcHandle;
  236.     *anErr = ::HandToHand((Handle *)aDstHandle);
  237.     SetZone(aZone);
  238. }
  239.  
  240.  
  241. //µ   HandleManager::DisposHandle
  242. #pragma segment HandleManager
  243. void HandleManager::DisposHandle(void **aHandle, OSErr *anErr)
  244. {
  245.     ::DisposHandle((Handle)aHandle);
  246.     *anErr = MemError();
  247. }
  248.  
  249.  
  250. //µ   HandleManager::FreeMem
  251. #pragma segment HandleManager
  252. size_t HandleManager::FreeMem()
  253. {
  254.     THz aZone = GetZone();
  255.  
  256.     SetZone(ApplicZone());
  257.     size_t aSize = (size_t)::FreeMem();
  258.     SetZone(aZone);
  259.  
  260.     return (aSize);
  261. }
  262.  
  263.  
  264. //µ   HandleManager::MaxMem
  265. #pragma segment HandleManager
  266. size_t HandleManager::MaxMem(size_t *grow)
  267. {
  268.     THz aZone = GetZone();
  269.  
  270.     SetZone(ApplicZone());
  271.     size_t aSize = (size_t)::MaxMem((Size *)grow);
  272.     SetZone(aZone);
  273.  
  274.     return (aSize);
  275. }
  276.  
  277.  
  278.  
  279.  
  280.  
  281.  
  282. static HandleManager gHandleProcApp;
  283. static SystemHandleManager gHandleProcSys;
  284. static TempHandleManager gHandleProcTemp;
  285.  
  286.  
  287.  
  288. //µ   HandleManager::GetManager
  289. //
  290. #pragma segment HandleManager
  291. HandleManager *HandleManager::GetManager(HandleManagerHeap whichHeap)
  292. {
  293.     switch (whichHeap) {
  294.     case kSysHandleManager:
  295.         return (&gHandleProcSys);
  296.         // break;
  297.  
  298.     case kTempHandleManager:
  299.         return (&gHandleProcTemp);
  300.         // break;
  301.  
  302.     case kAppHandleManager:
  303.     default:
  304.         return (&gHandleProcApp);
  305.         // break;
  306.     }
  307. }
  308.  
  309.  
  310. //µ   HandleManager::HandleManager
  311. #pragma segment HandleManager
  312. HandleManager *HandleManager::GetLargestManager()
  313. {
  314.     if (fMaySpecifyTempMemory && gHandleProcTemp.FreeMem() > gHandleProcApp.FreeMem())
  315.         return (&gHandleProcTemp);
  316.     else
  317.         return (&gHandleProcApp);
  318. }
  319.  
  320.  
  321.